/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#include "precomp.hpp"
#include <DeepSeaIF.h>

#if _MSC_VER >= 1200
#pragma comment(lib,"DeepSeaIF.lib")
#endif


/****************** Capturing video from TYZX stereo camera  *******************/
/** Initially developed by Roman Stanchak rstanchak@yahoo.com                  */

class CvCaptureCAM_TYZX : public CvCapture {
public:
    CvCaptureCAM_TYZX() { index = -1; image = 0; }
    virtual ~CvCaptureCAM_TYZX() { close(); }

    virtual bool open(int _index);
    virtual void close();
    bool isOpened() { return index >= 0; }

    virtual double getProperty(int);
    virtual bool setProperty(int, double) { return false; }
    virtual bool grabFrame();
    virtual IplImage* retrieveFrame(int);
    virtual int getCaptureDomain() { return CV_CAP_TYZX; } // Return the type of the capture object: CV_CAP_VFW, etc...

protected:
    virtual bool allocateImage();

    int index;
    IplImage* image;
}
CvCaptureCAM_TYZX;

DeepSeaIF* g_tyzx_camera   = 0;
int         g_tyzx_refcount = 0;

bool CvCaptureCAM_TYZX::open(int _index) {
    close();

    if (!g_tyzx_camera) {
        g_tyzx_camera = new DeepSeaIF;
        if (!g_tyzx_camera) { return false; }

        if (!g_tyzx_camera->initializeSettings(NULL)) {
            delete g_tyzx_camera;
            return false;
        }

        // set initial sensor mode
        // TODO is g_tyzx_camera redundant?
        g_tyzx_camera->setSensorMode(g_tyzx_camera->getSensorMode());

        // mm's
        g_tyzx_camera->setZUnits((int) 1000);

        g_tyzx_camera->enableLeftColor(true);
        g_tyzx_camera->setColorMode(DeepSeaIF::BGRcolor);
        g_tyzx_camera->setDoIntensityCrop(true);
        g_tyzx_camera->enable8bitImages(true);
        if (!g_tyzx_camera->startCapture()) {
            return false;
        }
        g_tyzx_refcount++;
    }
    index = _index;
    return true;
}

void CvCaptureCAM_TYZX::close() {
    if (isOpened()) {
        cvReleaseImage(&image);
        g_tyzx_refcount--;
        if (g_tyzx_refcount == 0) {
            delete g_tyzx_camera;
        }
    }
}

bool CvCaptureCAM_TYZX::grabFrame() {
    return isOpened() && g_tyzx_camera && g_tyzx_camera->grab();
}

bool CvCaptureCAM_TYZX::allocateImage() {
    int depth, nch;
    CvSize size;

    // assume we want to resize
    cvReleaseImage(&image);

    // figure out size depending on index provided
    switch (index) {
    case CV_TYZX_RIGHT:
        size = cvSize(g_tyzx_camera->intensityWidth(), g_tyzx_camera->intensityHeight());
        depth = 8;
        nch = 1;
        break;
    case CV_TYZX_Z:
        size = cvSize(g_tyzx_camera->zWidth(), g_tyzx_camera->zHeight());
        depth = IPL_DEPTH_16S;
        nch = 1;
        break;
    case CV_TYZX_LEFT:
    default:
        size = cvSize(g_tyzx_camera->intensityWidth(), g_tyzx_camera->intensityHeight());
        depth = 8;
        nch = 1;
        break;
    }
    image = cvCreateImage(size, depth, nch);
    return image != 0;
}

/// Copy 'grabbed' image into capture buffer and return it.
IplImage* CvCaptureCAM_TYZX::retrieveFrame(int) {
    if (!isOpened() || !g_tyzx_camera) { return 0; }

    if (!image && !alocateImage()) {
        return 0;
    }

    // copy camera image into buffer.
    // tempting to reference TYZX memory directly to avoid copying.
    switch (index) {
    case CV_TYZX_RIGHT:
        memcpy(image->imageData, g_tyzx_camera->getRImage(), image->imageSize);
        break;
    case CV_TYZX_Z:
        memcpy(image->imageData, g_tyzx_camera->getZImage(), image->imageSize);
        break;
    case CV_TYZX_LEFT:
    default:
        memcpy(image->imageData, g_tyzx_camera->getLImage(), image->imageSize);
        break;
    }

    return image;
}

double CvCaptureCAM_TYZX::getProperty(int property_id) {
    CvSize size;
    switch (capture->index) {
    case CV_TYZX_LEFT:
        size = cvSize(g_tyzx_camera->intensityWidth(), g_tyzx_camera->intensityHeight());
        break;
    case CV_TYZX_RIGHT:
        size = cvSize(g_tyzx_camera->intensityWidth(), g_tyzx_camera->intensityHeight());
        break;
    case CV_TYZX_Z:
        size = cvSize(g_tyzx_camera->zWidth(), g_tyzx_camera->zHeight());
        break;
    default:
        size = cvSize(0, 0);
    }

    switch (property_id) {
    case CV_CAP_PROP_FRAME_WIDTH:
        return size.width;
    case CV_CAP_PROP_FRAME_HEIGHT:
        return size.height;
    }

    return 0;
}

bool CvCaptureCAM_TYZX::setProperty(int, double) {
    return false;
}

CvCapture* cvCreateCameraCapture_TYZX(int index) {
    CvCaptureCAM_TYZX* capture = new CvCaptureCAM_TYZX;
    if (capture->open(index)) {
        return capture;
    }

    delete capture;
    return 0;
}
